#ifndef _THREAD_HPP__
#define _THREAD_HPP__

#include <iostream>
#include <string>
#include <pthread.h>
#include <functional>
#include <sys/types.h>
#include <unistd.h>

namespace ThreadModule
{
    //函数包装
    using func_t = std::function<void(std::string)>;
    //线程个数
    static int number = 1;
    //状态
    enum class TSTATUS
    {
        NEW,
        RUNNING,
        STOP
    };

    class Thread
    {
    private:
        //执行线程函数
        static void *Routine(void *args)
        {
            //强制类型转换
            Thread* thread = (Thread*)args;

            std::cout<<"我是"<<thread->_name<<"  :";
            //调用任务
            thread->_func(thread->_name);
            
            return nullptr;
        }

    public:
        Thread(func_t func) : _func(func), _status(TSTATUS::NEW), _joinable(false)
        {
            _name = "Thread-" + std::to_string(number);
            _pid = getpid();
            number++;
        }

        //创建线程
        bool Start()
        {
            if (_status != TSTATUS::RUNNING) // 保证线程处于非运行状态
            {
                int n = pthread_create(&_tid, nullptr, Routine, (void *)this); // 创建线程
                if (n != 0)
                {
                    return false;
                }
                _status = TSTATUS::RUNNING; // 更新状态
                return true;
            }

            return false;
        }

        //取消线程
        bool Stop()
        {
            if(_status == TSTATUS::RUNNING) //保证线程处于运行状态
            {
                int n = pthread_cancel(_tid);   //取消线程
                if(n != 0)
                {
                    return false;
                }
                _status = TSTATUS::STOP; // 更新状态
                return true;
            }

            return false;
        }

        //等待线程
        bool Join()
        {
            //保证线程不处于分离状态且处于运行状态
            if(!_joinable && _status == TSTATUS::RUNNING)  
            {   
                //等待线程，默认不关心线程状态
                int n = pthread_join(_tid,nullptr);
                if(n != 0)
                {
                    return false;
                }
                _status = TSTATUS::STOP; // 更新状态
                return true;
            }

            return false;
        }

        //线程分离
        void Detach()
        {
            //保证线程不处于分离状态且处于运行状态
            if(!_joinable && _status == TSTATUS::RUNNING)  
            {
               int n = pthread_detach(_tid);    //进行线程分离
               if(n != 0)
               {
                    return ;
               }
               std::cout<<"完成线程分离\n"<<std::endl;
               _joinable = true; //更新分离状态
            }
        }

        bool IsJoinable()
        {
            return _joinable;
        }

        std::string Name()
        {
            return _name;
        }

        ~Thread() {}

    private:
        std::string _name; // 线程name
        pthread_t _tid;    // 线程id
        pid_t _pid;        // 进程id
        bool _joinable;    // 是否是分离的，默认不是
        func_t _func;      // 线程执行的任务
        TSTATUS _status;   // 线程状态
    };
}

#endif